Software projects can include development of services, applications, and/or platforms and the components of those services, applications, and/or platforms that operate together to provide functionality. In many software project architectures, components may be dependent on one another, and a fault in a first component can cause downstream faults in those components dependent on the first component. For example, in a services oriented architecture, a first service may receive a request from a user application. To fulfill the request, the first service may request data from a second service. The second service may, in turn, request data from a third service and a fourth service. As a result, the first service is dependent on the second, third, and fourth services to fulfill the request from the user application and a fault in any of the first, second, third, or fourth services can cause an error when responding to the user application request.
Development of software projects, especially large scale software projects, can be done using an iterative lifecycle where source code modifications to the code base for the project are released periodically. For example, modifications can be made to source code to address defects, improve functionality, or provide additional features. During development, modifications to source code create an opportunity for inadvertent defects to arise in a particular iteration or version. For example, in some cases, correcting a fault in a component, such as a null pointer reference error, can introduce another fault such as an array out-of-bounds error in that same component. As another example, adding a new feature or modifying code for one component can introduce downstream faults in dependent components. For example, a source code modification to address a defect in a first component may cause the first component to incorrectly determine a data value provided to a second component resulting in a fault in the second component. As a result, some software development projects utilize regression testing before releasing an updated version of the code base to ensure that the software project still performs as expected. Regression testing can include, among other things, executing unit tests, component tests, and/or integration tests on the code base. Unit testing can include testing discrete functionality, such as a function or method of a component, separate from the rest of the component. Component testing can include testing the overall functionality of a component separate from the other components in the overall architecture. Integration testing can include applying a test plan to multiple components with the goal of testing behavior of the overall architecture, or a part of the overall architecture. While unit testing, component testing, and integration testing are generally automated, time and resources (including manpower and computing resources) must be devoted to development and execution of the test cases used in such testing.